home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 August (Alt) / CHIP 2005-08.1.iso / program / guvenlik / syslinux-3.07.exe / com32 / lib / libpng / pngmem.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-01-08  |  16.2 KB  |  596 lines
  1.  
  2. /* pngmem.c - stub functions for memory allocation
  3.  *
  4.  * libpng version 1.2.8 - December 3, 2004
  5.  * For conditions of distribution and use, see copyright notice in png.h
  6.  * Copyright (c) 1998-2004 Glenn Randers-Pehrson
  7.  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  8.  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  9.  *
  10.  * This file provides a location for all memory allocation.  Users who
  11.  * need special memory handling are expected to supply replacement
  12.  * functions for png_malloc() and png_free(), and to use
  13.  * png_create_read_struct_2() and png_create_write_struct_2() to
  14.  * identify the replacement functions.
  15.  */
  16.  
  17. #define PNG_INTERNAL
  18. #include "png.h"
  19.  
  20. /* Borland DOS special memory handler */
  21. #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
  22. /* if you change this, be sure to change the one in png.h also */
  23.  
  24. /* Allocate memory for a png_struct.  The malloc and memset can be replaced
  25.    by a single call to calloc() if this is thought to improve performance. */
  26. png_voidp /* PRIVATE */
  27. png_create_struct(int type)
  28. {
  29. #ifdef PNG_USER_MEM_SUPPORTED
  30.    return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
  31. }
  32.  
  33. /* Alternate version of png_create_struct, for use with user-defined malloc. */
  34. png_voidp /* PRIVATE */
  35. png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
  36. {
  37. #endif /* PNG_USER_MEM_SUPPORTED */
  38.    png_size_t size;
  39.    png_voidp struct_ptr;
  40.  
  41.    if (type == PNG_STRUCT_INFO)
  42.      size = png_sizeof(png_info);
  43.    else if (type == PNG_STRUCT_PNG)
  44.      size = png_sizeof(png_struct);
  45.    else
  46.      return (png_get_copyright(NULL));
  47.  
  48. #ifdef PNG_USER_MEM_SUPPORTED
  49.    if(malloc_fn != NULL)
  50.    {
  51.       png_struct dummy_struct;
  52.       png_structp png_ptr = &dummy_struct;
  53.       png_ptr->mem_ptr=mem_ptr;
  54.       struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size);
  55.    }
  56.    else
  57. #endif /* PNG_USER_MEM_SUPPORTED */
  58.       struct_ptr = (png_voidp)farmalloc(size);
  59.    if (struct_ptr != NULL)
  60.       png_memset(struct_ptr, 0, size);
  61.    return (struct_ptr);
  62. }
  63.  
  64. /* Free memory allocated by a png_create_struct() call */
  65. void /* PRIVATE */
  66. png_destroy_struct(png_voidp struct_ptr)
  67. {
  68. #ifdef PNG_USER_MEM_SUPPORTED
  69.    png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
  70. }
  71.  
  72. /* Free memory allocated by a png_create_struct() call */
  73. void /* PRIVATE */
  74. png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
  75.     png_voidp mem_ptr)
  76. {
  77. #endif
  78.    if (struct_ptr != NULL)
  79.    {
  80. #ifdef PNG_USER_MEM_SUPPORTED
  81.       if(free_fn != NULL)
  82.       {
  83.          png_struct dummy_struct;
  84.          png_structp png_ptr = &dummy_struct;
  85.          png_ptr->mem_ptr=mem_ptr;
  86.          (*(free_fn))(png_ptr, struct_ptr);
  87.          return;
  88.       }
  89. #endif /* PNG_USER_MEM_SUPPORTED */
  90.       farfree (struct_ptr);
  91.    }
  92. }
  93.  
  94. /* Allocate memory.  For reasonable files, size should never exceed
  95.  * 64K.  However, zlib may allocate more then 64K if you don't tell
  96.  * it not to.  See zconf.h and png.h for more information. zlib does
  97.  * need to allocate exactly 64K, so whatever you call here must
  98.  * have the ability to do that.
  99.  *
  100.  * Borland seems to have a problem in DOS mode for exactly 64K.
  101.  * It gives you a segment with an offset of 8 (perhaps to store its
  102.  * memory stuff).  zlib doesn't like this at all, so we have to
  103.  * detect and deal with it.  This code should not be needed in
  104.  * Windows or OS/2 modes, and only in 16 bit mode.  This code has
  105.  * been updated by Alexander Lehmann for version 0.89 to waste less
  106.  * memory.
  107.  *
  108.  * Note that we can't use png_size_t for the "size" declaration,
  109.  * since on some systems a png_size_t is a 16-bit quantity, and as a
  110.  * result, we would be truncating potentially larger memory requests
  111.  * (which should cause a fatal error) and introducing major problems.
  112.  */
  113.  
  114. png_voidp PNGAPI
  115. png_malloc(png_structp png_ptr, png_uint_32 size)
  116. {
  117.    png_voidp ret;
  118.  
  119.    if (png_ptr == NULL || size == 0)
  120.       return (NULL);
  121.  
  122. #ifdef PNG_USER_MEM_SUPPORTED
  123.    if(png_ptr->malloc_fn != NULL)
  124.        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
  125.    else
  126.        ret = (png_malloc_default(png_ptr, size));
  127.    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  128.        png_error(png_ptr, "Out of memory!");
  129.    return (ret);
  130. }
  131.  
  132. png_voidp PNGAPI
  133. png_malloc_default(png_structp png_ptr, png_uint_32 size)
  134. {
  135.    png_voidp ret;
  136. #endif /* PNG_USER_MEM_SUPPORTED */
  137.  
  138. #ifdef PNG_MAX_MALLOC_64K
  139.    if (size > (png_uint_32)65536L)
  140.    {
  141.       png_warning(png_ptr, "Cannot Allocate > 64K");
  142.       ret = NULL;
  143.    }
  144.    else
  145. #endif
  146.  
  147.    if (size != (size_t)size)
  148.      ret = NULL;
  149.    else if (size == (png_uint_32)65536L)
  150.    {
  151.       if (png_ptr->offset_table == NULL)
  152.       {
  153.          /* try to see if we need to do any of this fancy stuff */
  154.          ret = farmalloc(size);
  155.          if (ret == NULL || ((png_size_t)ret & 0xffff))
  156.          {
  157.             int num_blocks;
  158.             png_uint_32 total_size;
  159.             png_bytep table;
  160.             int i;
  161.             png_byte huge * hptr;
  162.  
  163.             if (ret != NULL)
  164.             {
  165.                farfree(ret);
  166.                ret = NULL;
  167.             }
  168.  
  169.             if(png_ptr->zlib_window_bits > 14)
  170.                num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14));
  171.             else
  172.                num_blocks = 1;
  173.             if (png_ptr->zlib_mem_level >= 7)
  174.                num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7));
  175.             else
  176.                num_blocks++;
  177.  
  178.             total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
  179.  
  180.             table = farmalloc(total_size);
  181.  
  182.             if (table == NULL)
  183.             {
  184. #ifndef PNG_USER_MEM_SUPPORTED
  185.                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  186.                   png_error(png_ptr, "Out Of Memory."); /* Note "O" and "M" */
  187.                else
  188.                   png_warning(png_ptr, "Out Of Memory.");
  189. #endif
  190.                return (NULL);
  191.             }
  192.  
  193.             if ((png_size_t)table & 0xfff0)
  194.             {
  195. #ifndef PNG_USER_MEM_SUPPORTED
  196.                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  197.                   png_error(png_ptr,
  198.                     "Farmalloc didn't return normalized pointer");
  199.                else
  200.                   png_warning(png_ptr,
  201.                     "Farmalloc didn't return normalized pointer");
  202. #endif
  203.                return (NULL);
  204.             }
  205.  
  206.             png_ptr->offset_table = table;
  207.             png_ptr->offset_table_ptr = farmalloc(num_blocks *
  208.                png_sizeof (png_bytep));
  209.  
  210.             if (png_ptr->offset_table_ptr == NULL)
  211.             {
  212. #ifndef PNG_USER_MEM_SUPPORTED
  213.                if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  214.                   png_error(png_ptr, "Out Of memory."); /* Note "O" and "M" */
  215.                else
  216.                   png_warning(png_ptr, "Out Of memory.");
  217. #endif
  218.                return (NULL);
  219.             }
  220.  
  221.             hptr = (png_byte huge *)table;
  222.             if ((png_size_t)hptr & 0xf)
  223.             {
  224.                hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
  225.                hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
  226.             }
  227.             for (i = 0; i < num_blocks; i++)
  228.             {
  229.                png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
  230.                hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
  231.             }
  232.  
  233.             png_ptr->offset_table_number = num_blocks;
  234.             png_ptr->offset_table_count = 0;
  235.             png_ptr->offset_table_count_free = 0;
  236.          }
  237.       }
  238.  
  239.       if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
  240.       {
  241. #ifndef PNG_USER_MEM_SUPPORTED
  242.          if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  243.             png_error(png_ptr, "Out of Memory."); /* Note "o" and "M" */
  244.          else
  245.             png_warning(png_ptr, "Out of Memory.");
  246. #endif
  247.          return (NULL);
  248.       }
  249.  
  250.       ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
  251.    }
  252.    else
  253.       ret = farmalloc(size);
  254.  
  255. #ifndef PNG_USER_MEM_SUPPORTED
  256.    if (ret == NULL)
  257.    {
  258.       if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  259.          png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */
  260.       else
  261.          png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */
  262.    }
  263. #endif
  264.  
  265.    return (ret);
  266. }
  267.  
  268. /* free a pointer allocated by png_malloc().  In the default
  269.    configuration, png_ptr is not used, but is passed in case it
  270.    is needed.  If ptr is NULL, return without taking any action. */
  271. void PNGAPI
  272. png_free(png_structp png_ptr, png_voidp ptr)
  273. {
  274.    if (png_ptr == NULL || ptr == NULL)
  275.       return;
  276.  
  277. #ifdef PNG_USER_MEM_SUPPORTED
  278.    if (png_ptr->free_fn != NULL)
  279.    {
  280.       (*(png_ptr->free_fn))(png_ptr, ptr);
  281.       return;
  282.    }
  283.    else png_free_default(png_ptr, ptr);
  284. }
  285.  
  286. void PNGAPI
  287. png_free_default(png_structp png_ptr, png_voidp ptr)
  288. {
  289. #endif /* PNG_USER_MEM_SUPPORTED */
  290.  
  291.    if (png_ptr->offset_table != NULL)
  292.    {
  293.       int i;
  294.  
  295.       for (i = 0; i < png_ptr->offset_table_count; i++)
  296.       {
  297.          if (ptr == png_ptr->offset_table_ptr[i])
  298.          {
  299.             ptr = NULL;
  300.             png_ptr->offset_table_count_free++;
  301.             break;
  302.          }
  303.       }
  304.       if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
  305.       {
  306.          farfree(png_ptr->offset_table);
  307.          farfree(png_ptr->offset_table_ptr);
  308.          png_ptr->offset_table = NULL;
  309.          png_ptr->offset_table_ptr = NULL;
  310.       }
  311.    }
  312.  
  313.    if (ptr != NULL)
  314.    {
  315.       farfree(ptr);
  316.    }
  317. }
  318.  
  319. #else /* Not the Borland DOS special memory handler */
  320.  
  321. /* Allocate memory for a png_struct or a png_info.  The malloc and
  322.    memset can be replaced by a single call to calloc() if this is thought
  323.    to improve performance noticably. */
  324. png_voidp /* PRIVATE */
  325. png_create_struct(int type)
  326. {
  327. #ifdef PNG_USER_MEM_SUPPORTED
  328.    return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL));
  329. }
  330.  
  331. /* Allocate memory for a png_struct or a png_info.  The malloc and
  332.    memset can be replaced by a single call to calloc() if this is thought
  333.    to improve performance noticably. */
  334. png_voidp /* PRIVATE */
  335. png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
  336. {
  337. #endif /* PNG_USER_MEM_SUPPORTED */
  338.    png_size_t size;
  339.    png_voidp struct_ptr;
  340.  
  341.    if (type == PNG_STRUCT_INFO)
  342.       size = png_sizeof(png_info);
  343.    else if (type == PNG_STRUCT_PNG)
  344.       size = png_sizeof(png_struct);
  345.    else
  346.       return (NULL);
  347.  
  348. #ifdef PNG_USER_MEM_SUPPORTED
  349.    if(malloc_fn != NULL)
  350.    {
  351.       png_struct dummy_struct;
  352.       png_structp png_ptr = &dummy_struct;
  353.       png_ptr->mem_ptr=mem_ptr;
  354.       struct_ptr = (*(malloc_fn))(png_ptr, size);
  355.       if (struct_ptr != NULL)
  356.          png_memset(struct_ptr, 0, size);
  357.       return (struct_ptr);
  358.    }
  359. #endif /* PNG_USER_MEM_SUPPORTED */
  360.  
  361. #if defined(__TURBOC__) && !defined(__FLAT__)
  362.    struct_ptr = (png_voidp)farmalloc(size);
  363. #else
  364. # if defined(_MSC_VER) && defined(MAXSEG_64K)
  365.    struct_ptr = (png_voidp)halloc(size,1);
  366. # else
  367.    struct_ptr = (png_voidp)malloc(size);
  368. # endif
  369. #endif
  370.    if (struct_ptr != NULL)
  371.       png_memset(struct_ptr, 0, size);
  372.  
  373.    return (struct_ptr);
  374. }
  375.  
  376.  
  377. /* Free memory allocated by a png_create_struct() call */
  378. void /* PRIVATE */
  379. png_destroy_struct(png_voidp struct_ptr)
  380. {
  381. #ifdef PNG_USER_MEM_SUPPORTED
  382.    png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL);
  383. }
  384.  
  385. /* Free memory allocated by a png_create_struct() call */
  386. void /* PRIVATE */
  387. png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
  388.     png_voidp mem_ptr)
  389. {
  390. #endif /* PNG_USER_MEM_SUPPORTED */
  391.    if (struct_ptr != NULL)
  392.    {
  393. #ifdef PNG_USER_MEM_SUPPORTED
  394.       if(free_fn != NULL)
  395.       {
  396.          png_struct dummy_struct;
  397.          png_structp png_ptr = &dummy_struct;
  398.          png_ptr->mem_ptr=mem_ptr;
  399.          (*(free_fn))(png_ptr, struct_ptr);
  400.          return;
  401.       }
  402. #endif /* PNG_USER_MEM_SUPPORTED */
  403. #if defined(__TURBOC__) && !defined(__FLAT__)
  404.       farfree(struct_ptr);
  405. #else
  406. # if defined(_MSC_VER) && defined(MAXSEG_64K)
  407.       hfree(struct_ptr);
  408. # else
  409.       free(struct_ptr);
  410. # endif
  411. #endif
  412.    }
  413. }
  414.  
  415. /* Allocate memory.  For reasonable files, size should never exceed
  416.    64K.  However, zlib may allocate more then 64K if you don't tell
  417.    it not to.  See zconf.h and png.h for more information.  zlib does
  418.    need to allocate exactly 64K, so whatever you call here must
  419.    have the ability to do that. */
  420.  
  421. png_voidp PNGAPI
  422. png_malloc(png_structp png_ptr, png_uint_32 size)
  423. {
  424.    png_voidp ret;
  425.  
  426. #ifdef PNG_USER_MEM_SUPPORTED
  427.    if (png_ptr == NULL || size == 0)
  428.       return (NULL);
  429.  
  430.    if(png_ptr->malloc_fn != NULL)
  431.        ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
  432.    else
  433.        ret = (png_malloc_default(png_ptr, size));
  434.    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  435.        png_error(png_ptr, "Out of Memory!");
  436.    return (ret);
  437. }
  438.  
  439. png_voidp PNGAPI
  440. png_malloc_default(png_structp png_ptr, png_uint_32 size)
  441. {
  442.    png_voidp ret;
  443. #endif /* PNG_USER_MEM_SUPPORTED */
  444.  
  445.    if (png_ptr == NULL || size == 0)
  446.       return (NULL);
  447.  
  448. #ifdef PNG_MAX_MALLOC_64K
  449.    if (size > (png_uint_32)65536L)
  450.    {
  451. #ifndef PNG_USER_MEM_SUPPORTED
  452.       if(png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  453.          png_error(png_ptr, "Cannot Allocate > 64K");
  454.       else
  455. #endif
  456.          return NULL;
  457.    }
  458. #endif
  459.  
  460.  /* Check for overflow */
  461. #if defined(__TURBOC__) && !defined(__FLAT__)
  462.  if (size != (unsigned long)size)
  463.    ret = NULL;
  464.  else
  465.    ret = farmalloc(size);
  466. #else
  467. # if defined(_MSC_VER) && defined(MAXSEG_64K)
  468.  if (size != (unsigned long)size)
  469.    ret = NULL;
  470.  else
  471.    ret = halloc(size, 1);
  472. # else
  473.  if (size != (size_t)size)
  474.    ret = NULL;
  475.  else
  476.    ret = malloc((size_t)size);
  477. # endif
  478. #endif
  479.  
  480. #ifndef PNG_USER_MEM_SUPPORTED
  481.    if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
  482.       png_error(png_ptr, "Out of Memory");
  483. #endif
  484.  
  485.    return (ret);
  486. }
  487.  
  488. /* Free a pointer allocated by png_malloc().  If ptr is NULL, return
  489.    without taking any action. */
  490. void PNGAPI
  491. png_free(png_structp png_ptr, png_voidp ptr)
  492. {
  493.    if (png_ptr == NULL || ptr == NULL)
  494.       return;
  495.  
  496. #ifdef PNG_USER_MEM_SUPPORTED
  497.    if (png_ptr->free_fn != NULL)
  498.    {
  499.       (*(png_ptr->free_fn))(png_ptr, ptr);
  500.       return;
  501.    }
  502.    else png_free_default(png_ptr, ptr);
  503. }
  504. void PNGAPI
  505. png_free_default(png_structp png_ptr, png_voidp ptr)
  506. {
  507.    if (png_ptr == NULL || ptr == NULL)
  508.       return;
  509.  
  510. #endif /* PNG_USER_MEM_SUPPORTED */
  511.  
  512. #if defined(__TURBOC__) && !defined(__FLAT__)
  513.    farfree(ptr);
  514. #else
  515. # if defined(_MSC_VER) && defined(MAXSEG_64K)
  516.    hfree(ptr);
  517. # else
  518.    free(ptr);
  519. # endif
  520. #endif
  521. }
  522.  
  523. #endif /* Not Borland DOS special memory handler */
  524.  
  525. #if defined(PNG_1_0_X)
  526. #  define png_malloc_warn png_malloc
  527. #else
  528. /* This function was added at libpng version 1.2.3.  The png_malloc_warn()
  529.  * function will set up png_malloc() to issue a png_warning and return NULL
  530.  * instead of issuing a png_error, if it fails to allocate the requested
  531.  * memory.
  532.  */
  533. png_voidp PNGAPI
  534. png_malloc_warn(png_structp png_ptr, png_uint_32 size)
  535. {
  536.    png_voidp ptr;
  537.    png_uint_32 save_flags=png_ptr->flags;
  538.  
  539.    png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
  540.    ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
  541.    png_ptr->flags=save_flags;
  542.    return(ptr);
  543. }
  544. #endif
  545.  
  546. png_voidp PNGAPI
  547. png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2,
  548.    png_uint_32 length)
  549. {
  550.    png_size_t size;
  551.  
  552.    size = (png_size_t)length;
  553.    if ((png_uint_32)size != length)
  554.       png_error(png_ptr,"Overflow in png_memcpy_check.");
  555.  
  556.    return(png_memcpy (s1, s2, size));
  557. }
  558.  
  559. png_voidp PNGAPI
  560. png_memset_check (png_structp png_ptr, png_voidp s1, int value,
  561.    png_uint_32 length)
  562. {
  563.    png_size_t size;
  564.  
  565.    size = (png_size_t)length;
  566.    if ((png_uint_32)size != length)
  567.       png_error(png_ptr,"Overflow in png_memset_check.");
  568.  
  569.    return (png_memset (s1, value, size));
  570.  
  571. }
  572.  
  573. #ifdef PNG_USER_MEM_SUPPORTED
  574. /* This function is called when the application wants to use another method
  575.  * of allocating and freeing memory.
  576.  */
  577. void PNGAPI
  578. png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
  579.   malloc_fn, png_free_ptr free_fn)
  580. {
  581.    png_ptr->mem_ptr = mem_ptr;
  582.    png_ptr->malloc_fn = malloc_fn;
  583.    png_ptr->free_fn = free_fn;
  584. }
  585.  
  586. /* This function returns a pointer to the mem_ptr associated with the user
  587.  * functions.  The application should free any memory associated with this
  588.  * pointer before png_write_destroy and png_read_destroy are called.
  589.  */
  590. png_voidp PNGAPI
  591. png_get_mem_ptr(png_structp png_ptr)
  592. {
  593.    return ((png_voidp)png_ptr->mem_ptr);
  594. }
  595. #endif /* PNG_USER_MEM_SUPPORTED */
  596.